diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index a102cc9..66a1cff 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -91,6 +91,7 @@
     <li>Added titles to all user manual pages.</li>
 	<li>Added Compat.php to allow function overrides for older versions of PHP or PHP environments missing certain extensions / libraries</li>
     <li>Added <a href="http://codeigniter.com/user_guide/libraries/zip.html">Zip Encoding Class</a> to the table of contents of the userguide.</li>
+	<li>Added memory usage, GET, and URI string data to Profiler output.</li>
     <li>Moved the safe mode and auth checks for the Email library into the constructor. </li>
     <li>Moved part of the userguide menu javascript to an external file.</li>
 	<li>Modified variable names in _ci_load() method of Loader class to avoid conflicts with view variables.</li>
